DemoApplicationWindow *window = (DemoApplicationWindow *)widget;
GdkSurfaceState new_state;
- new_state = gdk_surface_get_state (gtk_widget_get_surface (widget));
+ new_state = gdk_surface_get_state (gtk_native_get_surface (GTK_NATIVE (widget)));
window->maximized = (new_state & GDK_SURFACE_STATE_MAXIMIZED) != 0;
window->fullscreen = (new_state & GDK_SURFACE_STATE_FULLSCREEN) != 0;
}
{
GTK_WIDGET_CLASS (demo_application_window_parent_class)->realize (widget);
- g_signal_connect_swapped (gtk_widget_get_surface (widget), "notify::state",
+ g_signal_connect_swapped (gtk_native_get_surface (GTK_NATIVE (widget)), "notify::state",
G_CALLBACK (surface_state_changed), widget);
}
static void
demo_application_window_unrealize (GtkWidget *widget)
{
- g_signal_handlers_disconnect_by_func (gtk_widget_get_surface (widget),
+ g_signal_handlers_disconnect_by_func (gtk_native_get_surface (GTK_NATIVE (widget)),
surface_state_changed, widget);
GTK_WIDGET_CLASS (demo_application_window_parent_class)->unrealize (widget);
device = gtk_get_current_event_device ();
if (gdk_seat_grab (gdk_device_get_seat (device),
- gtk_widget_get_surface (popup),
+ gtk_native_get_surface (GTK_NATIVE (popup)),
GDK_SEAT_CAPABILITY_ALL_POINTING,
FALSE, cursor, NULL, NULL, NULL) == GDK_GRAB_SUCCESS)
{
rect.height = 0;
gtk_menu_popup_at_rect (GTK_MENU (menu),
- gtk_widget_get_surface (widget),
+ gtk_native_get_surface (gtk_widget_get_native (widget)),
&rect,
GDK_GRAVITY_NORTH_WEST,
GDK_GRAVITY_NORTH_WEST,
GdkSurface *surface;
GdkPaintable *paintable;
- surface = gtk_widget_get_surface (GTK_WIDGET (self));
+ surface = gtk_native_get_surface (GTK_NATIVE (self));
g_assert (surface != NULL);
if (renderer != NULL && !gsk_renderer_realize (renderer, surface, NULL))
GtkApplication *app = gtk_window_get_application (GTK_WINDOW (window));
gtk_widget_set_sensitive (window, TRUE);
- gdk_surface_set_cursor (gtk_widget_get_surface (window), NULL);
+ gdk_surface_set_cursor (gtk_native_get_surface (GTK_NATIVE (window)), NULL);
g_application_unmark_busy (G_APPLICATION (app));
return G_SOURCE_REMOVE;
g_application_mark_busy (G_APPLICATION (app));
cursor = gdk_cursor_new_from_name ("wait", NULL);
- gdk_surface_set_cursor (gtk_widget_get_surface (window), cursor);
+ gdk_surface_set_cursor (gtk_native_get_surface (GTK_NATIVE (window)), cursor);
g_object_unref (cursor);
g_timeout_add (5000, get_idle, window);
gtk_main_quit ();
}
- window = gtk_widget_get_surface (info->window);
+ window = gtk_native_get_surface (GTK_NATIVE (info->window));
id = gdk_x11_surface_get_xid (window);
if (window_is_csd (window))
decor = (info->include_decorations) ? DECOR_NONE : DECOR_WINDOW_FRAME;
surface = NULL;
}
- if (gtk_widget_get_surface (widget))
+ if (gtk_native_get_surface (gtk_widget_get_native (widget)))
{
- surface = gdk_surface_create_similar_surface (gtk_widget_get_surface (widget),
+ surface = gdk_surface_create_similar_surface (gtk_native_get_surface (gtk_widget_get_native (widget)),
CAIRO_CONTENT_COLOR,
gtk_widget_get_width (widget),
gtk_widget_get_height (widget));
{
GdkSurface *surface;
- surface = gtk_widget_get_surface (widget);
+ surface = gtk_native_get_surface (gtk_widget_get_native (widget));
gdk_surface_get_origin (surface, x_surface, y_surface);
gdk_surface_get_origin (surface, x_toplevel, y_toplevel);
toplevel = gtk_widget_get_toplevel (widget);
if (gtk_widget_is_toplevel (toplevel))
{
-#ifdef GDK_WINDOWING_X11
- if (GDK_IS_X11_DISPLAY (gtk_widget_get_display (toplevel)))
- gtk_window_present_with_time (GTK_WINDOW (toplevel),
- gdk_x11_get_server_time (gtk_widget_get_surface (widget)));
- else
-#endif
- {
- G_GNUC_BEGIN_IGNORE_DEPRECATIONS
- gtk_window_present (GTK_WINDOW (toplevel));
- G_GNUC_END_IGNORE_DEPRECATIONS
- }
+ G_GNUC_BEGIN_IGNORE_DEPRECATIONS
+ gtk_window_present (GTK_WINDOW (toplevel));
+ G_GNUC_END_IGNORE_DEPRECATIONS
}
return TRUE;
toplevel = gtk_widget_get_toplevel (widget);
if (gtk_widget_is_toplevel (toplevel))
{
-#ifdef GDK_WINDOWING_X11
- gtk_window_present_with_time (GTK_WINDOW (toplevel),
- gdk_x11_get_server_time (gtk_widget_get_surface (widget)));
-#else
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
gtk_window_present (GTK_WINDOW (toplevel));
G_GNUC_END_IGNORE_DEPRECATIONS
-#endif
}
return TRUE;
#include "gtklabel.h"
#include "gtkwidgetprivate.h"
#include "gtkwindowprivate.h"
+#include "gtknative.h"
/* atkcomponent.h */
if (gtk_window_is_active (window))
atk_state_set_add_state (state_set, ATK_STATE_ACTIVE);
- gdk_surface = gtk_widget_get_surface (widget);
+ gdk_surface = gtk_native_get_surface (GTK_NATIVE (window));
if (gdk_surface)
{
state = gdk_surface_get_state (gdk_surface);
return;
}
- surface = gtk_widget_get_surface (widget);
+ surface = gtk_native_get_surface (GTK_NATIVE (widget));
if (surface == NULL)
return;
return;
}
- surface = gtk_widget_get_surface (widget);
+ surface = gtk_native_get_surface (GTK_NATIVE (widget));
if (surface == NULL)
return;
#include "config.h"
#include "gtkapplicationprivate.h"
+#include "gtknative.h"
#include <gdk/wayland/gdkwayland.h>
GdkSurface *gdk_surface;
gchar *window_path;
- gdk_surface = gtk_widget_get_surface (GTK_WIDGET (window));
+ gdk_surface = gtk_native_get_surface (GTK_NATIVE (window));
if (!GDK_IS_WAYLAND_SURFACE (gdk_surface))
return;
#include "config.h"
#include "gtkapplicationprivate.h"
+#include "gtknative.h"
#include <gdk/x11/gdkx.h>
GdkSurface *gdk_surface;
gchar *window_path;
- gdk_surface = gtk_widget_get_surface (GTK_WIDGET (window));
+ gdk_surface = gtk_native_get_surface (GTK_NATIVE (window));
if (!GDK_IS_X11_SURFACE (gdk_surface))
return;
{
GdkSurface *gdk_surface;
- gdk_surface = gtk_widget_get_surface (GTK_WIDGET (window));
+ gdk_surface = gtk_native_get_surface (GTK_NATIVE (window));
if (GDK_IS_X11_SURFACE (gdk_surface))
return g_variant_new_uint32 (GDK_SURFACE_XID (gdk_surface));
#include "gtktypebuiltins.h"
#include "gtkprivate.h"
#include "gtkeventcontrollerkey.h"
+#include "gtknative.h"
/**
if (!is_editable)
return NULL;
- surface = gtk_widget_get_surface (widget);
+ surface = gtk_native_get_surface (gtk_widget_get_native (widget));
if (event)
seat = gdk_event_get_seat (event);
#include "gtkwidgetprivate.h"
#include "gtkwindowgroup.h"
#include "gtkwindowprivate.h"
+#include "gtknative.h"
#include "gdk/gdkcontentformatsprivate.h"
#include "gdk/gdktextureprivate.h"
int y)
{
GtkDragSourceInfo *info;
- GtkRoot *root;
+ GtkNative *native;
GdkDrag *drag;
double px, py;
int dx, dy;
if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
device = gdk_device_get_associated_device (device);
- root = gtk_widget_get_root (widget);
- gtk_widget_translate_coordinates (widget, GTK_WIDGET (root), x, y, &x, &y);
- gdk_surface_get_device_position (gtk_widget_get_surface (widget),
+ native = gtk_widget_get_native (widget);
+ gtk_widget_translate_coordinates (widget, GTK_WIDGET (native), x, y, &x, &y);
+ gdk_surface_get_device_position (gtk_native_get_surface (native),
device,
&px, &py,
NULL);
content->widget = g_object_ref (widget);
content->formats = gdk_content_formats_ref (target_list);
- drag = gdk_drag_begin (gtk_widget_get_surface (GTK_WIDGET (root)), device, GDK_CONTENT_PROVIDER (content), actions, dx, dy);
+ drag = gdk_drag_begin (gtk_native_get_surface (native), device, GDK_CONTENT_PROVIDER (content), actions, dx, dy);
if (drag == NULL)
{
g_object_unref (content);
#include "gtkdnd.h"
#include "gtkdndprivate.h"
#include "gtkintl.h"
+#include "gtknative.h"
static void
gtk_drag_dest_realized (GtkWidget *widget)
{
- GtkRoot *root = gtk_widget_get_root (widget);
+ GtkNative *native = gtk_widget_get_native (widget);
- gdk_surface_register_dnd (gtk_widget_get_surface (GTK_WIDGET (root)));
+ gdk_surface_register_dnd (gtk_native_get_surface (native));
}
static void
GParamSpec *pspec,
gpointer data)
{
- GtkRoot *root = gtk_widget_get_root (widget);
+ GtkNative *native = gtk_widget_get_native (widget);
- if (root && gtk_widget_get_realized (GTK_WIDGET (root)))
- gdk_surface_register_dnd (gtk_widget_get_surface (GTK_WIDGET (root)));
+ if (native && gtk_widget_get_realized (GTK_WIDGET (native)))
+ gdk_surface_register_dnd (gtk_native_get_surface (native));
}
static void
* {
* GdkModifierType mask;
*
- * gdk_surface_get_pointer (gtk_widget_get_surface (widget),
+ * gdk_surface_get_pointer (gtk_native_get_surface (gtk_widget_get_native (widget)),
* NULL, NULL, &mask);
* if (mask & GDK_CONTROL_MASK)
* gdk_drag_status (context, GDK_ACTION_COPY, time);
#include "gtkprivate.h"
#include "gtkwindowprivate.h"
#include "gtkwidgetprivate.h"
+#include "gtknative.h"
#include <string.h>
GtkTreeViewColumn *action_column;
gint action_height;
- surface = gtk_widget_get_surface (completion->priv->entry);
+ surface = gtk_native_get_surface (gtk_widget_get_native (completion->priv->entry));
if (!surface)
return;
if (transient_for)
{
gtk_widget_realize (GTK_WIDGET (transient_for));
- data->parent = gdk_quartz_surface_get_nswindow (gtk_widget_get_surface (GTK_WIDGET (transient_for)));
+ data->parent = gdk_quartz_surface_get_nswindow (gtk_native_get_surface (GTK_NATIVE (transient_for)));
if (gtk_native_dialog_get_modal (GTK_NATIVE_DIALOG (self)))
data->modal = TRUE;
#include "gtklabel.h"
#include "gtkfilechooserentry.h"
#include "gtkfilefilterprivate.h"
+#include "gtknative.h"
#include "win32/gdkwin32.h"
#include <shlobj.h>
if (transient_for)
{
gtk_widget_realize (GTK_WIDGET (transient_for));
- data->parent = gdk_win32_surface_get_handle (gtk_widget_get_surface (GTK_WIDGET (transient_for)));
+ data->parent = gdk_win32_surface_get_handle (gtk_native_get_surface (GTK_NATIVE (transient_for)));
if (gtk_native_dialog_get_modal (GTK_NATIVE_DIALOG (self)))
data->modal = TRUE;
#include "gtkprivate.h"
#include "gtkmain.h"
#include "gtkintl.h"
+#include "gtknative.h"
typedef struct _GtkGesturePrivate GtkGesturePrivate;
typedef struct _PointData PointData;
GtkWidget *widget;
widget = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture));
- return surface == gtk_widget_get_surface (widget);
+ return surface == gtk_native_get_surface (gtk_widget_get_native (widget));
}
static gboolean
#include "gtkprivate.h"
#include "gtkrender.h"
#include "gtksnapshot.h"
+#include "gtknative.h"
#include <epoxy/gl.h>
GError *error = NULL;
GdkGLContext *context;
- context = gdk_surface_create_gl_context (gtk_widget_get_surface (widget), &error);
+ context = gdk_surface_create_gl_context (gtk_native_get_surface (gtk_widget_get_native (widget)), &error);
if (error != NULL)
{
gtk_gl_area_set_error (area, error);
#include "gtktypebuiltins.h"
#include "gtkwidgetprivate.h"
#include "gtkwindowprivate.h"
+#include "gtknative.h"
#include "a11y/gtkcontaineraccessible.h"
G_CALLBACK (_gtk_header_bar_update_window_buttons), widget);
g_signal_connect_swapped (settings, "notify::gtk-decoration-layout",
G_CALLBACK (_gtk_header_bar_update_window_buttons), widget);
- g_signal_connect_swapped (_gtk_widget_get_surface (widget), "notify::state",
+ g_signal_connect_swapped (gtk_native_get_surface (gtk_widget_get_native (widget)), "notify::state",
G_CALLBACK (surface_state_changed), widget);
_gtk_header_bar_update_window_buttons (GTK_HEADER_BAR (widget));
}
settings = gtk_widget_get_settings (widget);
g_signal_handlers_disconnect_by_func (settings, _gtk_header_bar_update_window_buttons, widget);
- g_signal_handlers_disconnect_by_func (_gtk_widget_get_surface (widget), surface_state_changed, widget);
+ g_signal_handlers_disconnect_by_func (gtk_native_get_surface (gtk_widget_get_native (widget)), surface_state_changed, widget);
GTK_WIDGET_CLASS (gtk_header_bar_parent_class)->unrealize (widget);
}
GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
GdkSurfaceState changed, new_state;
- new_state = gdk_surface_get_state (_gtk_widget_get_surface (widget));
+ new_state = gdk_surface_get_state (gtk_native_get_surface (gtk_widget_get_native (widget)));
changed = new_state ^ priv->state;
priv->state = new_state;
GtkWidget *widget)
{
GtkIMContextIME *context_ime;
- GtkWidget *toplevel;
GdkSurface *client_surface;
g_return_if_fail (GTK_IS_IM_CONTEXT_IME (context));
context_ime = GTK_IM_CONTEXT_IME (context);
- toplevel = gtk_widget_get_toplevel (widget);
- client_surface = gtk_widget_get_surface (toplevel);
+ client_surface = gtk_native_get_surface (gtk_widget_get_native (widget));
if (client_surface)
{
GdkSurface *surface = NULL;
if (widget != NULL)
- surface = gtk_widget_get_surface (gtk_widget_get_toplevel (widget));
+ surface = gtk_native_get_surface (gtk_widget_get_native (widget));
set_ic_client_surface (context_xim, surface);
}
gdouble x, y;
event = gdk_event_new (enter ? GDK_ENTER_NOTIFY : GDK_LEAVE_NOTIFY);
if (related_target)
- event->crossing.child_surface = g_object_ref (gtk_widget_get_surface (related_target));
+ {
+ GdkSurface *surface;
+
+ surface = gtk_native_get_surface (gtk_widget_get_native (related_target));
+ event->crossing.child_surface = g_object_ref (surface);
+ }
gdk_event_get_coords (source, &x, &y);
event->crossing.x = x;
event->crossing.y = y;
gdk_event_set_device (event, gdk_event_get_device (source));
gdk_event_set_source_device (event, gdk_event_get_source_device (source));
- event->any.surface = gtk_widget_get_surface (toplevel);
+ event->any.surface = gtk_native_get_surface (gtk_widget_get_native (toplevel));
if (event->any.surface)
g_object_ref (event->any.surface);
#include "gtkwindowgroup.h"
#include "gtkwindowprivate.h"
#include "gtkeventcontrollerkey.h"
+#include "gtknative.h"
#include "a11y/gtkmenuaccessible.h"
GdkSurface *toplevel_surface;
GdkSurface *transfer_surface;
- toplevel_surface = gtk_widget_get_surface (priv->toplevel);
+ toplevel_surface = gtk_native_get_surface (GTK_NATIVE (priv->toplevel));
transfer_surface = g_object_get_data (G_OBJECT (menu), "gtk-menu-transfer-surface");
if (toplevel_surface == NULL || transfer_surface == NULL)
if (xgrab_shell && xgrab_shell != widget)
{
- if (popup_grab_on_surface (gtk_widget_get_surface (xgrab_shell), pointer))
+ if (popup_grab_on_surface (gtk_native_get_surface (gtk_widget_get_native (xgrab_shell)), pointer))
{
_gtk_menu_shell_set_grab_device (GTK_MENU_SHELL (xgrab_shell), pointer);
GTK_MENU_SHELL (xgrab_shell)->priv->have_xgrab = TRUE;
gtk_widget_show (priv->toplevel);
if (xgrab_shell == widget)
- popup_grab_on_surface (gtk_widget_get_surface (widget), pointer); /* Should always succeed */
+ popup_grab_on_surface (gtk_native_get_surface (gtk_widget_get_native (widget)), pointer); /* Should always succeed */
gtk_grab_add (GTK_WIDGET (menu));
gdk_surface_destroy (surface);
g_object_set_data (G_OBJECT (menu), I_("gtk-menu-transfer-surface"), NULL);
- widget_surface = gtk_widget_get_surface (GTK_WIDGET (menu));
+ widget_surface = gtk_native_get_surface (gtk_widget_get_native (GTK_WIDGET (menu)));
g_object_set_data (G_OBJECT (widget_surface), I_("gdk-attached-grab-surface"), surface);
}
}
GtkMenuShell *menu_shell;
gint surface_x, surface_y;
- gdk_surface_get_position (gtk_widget_get_surface (priv->toplevel),
+ gdk_surface_get_position (gtk_native_get_surface (GTK_NATIVE (priv->toplevel)),
&surface_x, &surface_y);
gtk_widget_get_allocation (widget, &allocation);
if ((priv->scroll_offset >= 0) && (offset < 0))
offset = 0;
- view_height = gdk_surface_get_height (gtk_widget_get_surface (widget));
+ view_height = gdk_surface_get_height (gtk_native_get_surface (gtk_widget_get_native (widget)));
if (priv->scroll_offset == 0 &&
view_height >= priv->requested_height)
&bottom_arrow_height, NULL,
NULL, NULL);
- surface = gtk_widget_get_surface (widget);
+ surface = gtk_native_get_surface (gtk_widget_get_native (widget));
width = gdk_surface_get_width (surface);
height = gdk_surface_get_height (surface);
menu_shell = GTK_MENU_SHELL (menu);
- gdk_surface_get_position (gtk_widget_get_surface (priv->toplevel),
+ gdk_surface_get_position (gtk_native_get_surface (GTK_NATIVE (priv->toplevel)),
&top_x, &top_y);
x -= top_x;
y -= top_y;
gint surface_x, surface_y;
gtk_widget_get_allocation (GTK_WIDGET (menu), &allocation);
- gdk_surface_get_position (gtk_widget_get_surface (priv->toplevel),
+ gdk_surface_get_position (gtk_native_get_surface (GTK_NATIVE (priv->toplevel)),
&surface_x, &surface_y);
if (x_root >= surface_x && x_root < surface_x + allocation.width &&
y_diff = y_root - priv->drag_start_y;
offset = priv->initial_drag_offset - y_diff;
- view_height = gdk_surface_get_height (gtk_widget_get_surface (widget));
+ view_height = gdk_surface_get_height (gtk_native_get_surface (gtk_widget_get_native (widget)));
get_arrows_border (menu, &arrow_border);
if (gtk_widget_get_child_visible (priv->top_arrow_widget))
}
else if (priv->widget)
{
- rect_surface = gtk_widget_get_surface (priv->widget);
+ rect_surface = gtk_native_get_surface (gtk_widget_get_native (priv->widget));
gtk_widget_get_surface_allocation (priv->widget, &rect);
text_direction = gtk_widget_get_direction (priv->widget);
}
menu_anchor = get_horizontally_flipped_anchor (menu_anchor);
}
- toplevel = gtk_widget_get_surface (priv->toplevel);
+ toplevel = gtk_native_get_surface (GTK_NATIVE (priv->toplevel));
gdk_surface_set_transient_for (toplevel, rect_surface);
if (compute_child_offset (menu, menu_item, &child_offset, &child_height))
{
y = priv->scroll_offset;
- height = gdk_surface_get_height (gtk_widget_get_surface (widget));
+ height = gdk_surface_get_height (gtk_native_get_surface (gtk_widget_get_native (widget)));
if (child_offset < y)
{
#include "gtkstylecontextprivate.h"
#include "gtkcssstylepropertyprivate.h"
#include "gtkiconprivate.h"
+#include "gtknative.h"
#define MENU_POPUP_DELAY 225
/* Position the submenu at the menu item if it is mapped.
* Otherwise, position the submenu at the pointer device.
*/
- if (gtk_widget_get_surface (widget))
+ if (gtk_native_get_surface (gtk_widget_get_native (widget)))
{
switch (priv->submenu_placement)
{
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
+#include "config.h"
+
#include "gtkmnemonichash.h"
+#include "gtknative.h"
struct _GtkMnemnonicHash
{
for (list = targets; list; list = list->next)
{
widget = GTK_WIDGET (list->data);
- surface = gtk_widget_get_surface (widget);
+ surface = gtk_native_get_surface (gtk_widget_get_native (widget));
if (gtk_widget_is_sensitive (widget) &&
gtk_widget_get_mapped (widget) &&
page->mnemonic_activate_signal);
page->mnemonic_activate_signal = 0;
- if (gtk_widget_get_surface (page->tab_label) != gtk_widget_get_surface (GTK_WIDGET (notebook)) ||
+ if (gtk_widget_get_native (page->tab_label) != gtk_widget_get_native (GTK_WIDGET (notebook)) ||
!NOTEBOOK_IS_TAB_LABEL_PARENT (notebook, page))
{
GtkWidget *parent;
GdkSurfaceState new_surface_state;
GdkSurfaceState changed_mask;
- new_surface_state = gdk_surface_get_state (_gtk_widget_get_surface (widget));
+ new_surface_state = gdk_surface_get_state (priv->surface);
changed_mask = new_surface_state ^ priv->state;
priv->state = new_surface_state;
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
GdkRectangle parent_rect;
GdkDisplay *display;
+ GdkSurface *parent;
gtk_widget_get_surface_allocation (priv->relative_to, &parent_rect);
display = gtk_widget_get_display (priv->relative_to);
- priv->surface = gdk_surface_new_popup (display, gtk_widget_get_surface (priv->relative_to), priv->autohide);
+ parent = gtk_native_get_surface (gtk_widget_get_native (priv->relative_to));
+ priv->surface = gdk_surface_new_popup (display, parent, priv->autohide);
gdk_surface_set_widget (priv->surface, widget);
static void
gtk_popover_update_shape (GtkPopover *popover)
{
+ GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
GtkWidget *widget = GTK_WIDGET (popover);
cairo_surface_t *cairo_surface;
cairo_region_t *region;
- GdkSurface *surface;
cairo_t *cr;
-#ifdef GDK_WINDOWING_WAYLAND
+#ifdef GDK_WINDOWING_WAYLAND
if (GDK_IS_WAYLAND_DISPLAY (gtk_widget_get_display (widget)))
return;
#endif
- surface = gtk_widget_get_surface (widget);
cairo_surface =
- gdk_surface_create_similar_surface (surface,
+ gdk_surface_create_similar_surface (priv->surface,
CAIRO_CONTENT_COLOR_ALPHA,
- gdk_surface_get_width (surface),
- gdk_surface_get_height (surface));
+ gdk_surface_get_width (priv->surface),
+ gdk_surface_get_height (priv->surface));
cr = cairo_create (cairo_surface);
gtk_popover_fill_border_path (popover, cr);
static HWND
get_parent_hwnd (GtkWidget *widget)
{
- gtk_widget_realize (widget);
- return gdk_win32_surface_get_handle (gtk_widget_get_surface (widget));
+ GtkNative *native;
+
+ native = gtk_widget_get_native (widget);
+ gtk_widget_realize (GTK_WIDGET (native));
+ return gdk_win32_surface_get_handle (gtk_native_get_surface (native));
}
static void
gboolean was_grabbed,
GtkPrintOperation *op)
{
- EnableWindow (GetAncestor (GDK_SURFACE_HWND (gtk_widget_get_surface (widget)), GA_ROOT),
+ EnableWindow (GetAncestor (GDK_SURFACE_HWND (gtk_native_get_surface (gtk_widget_get_native (widget))), GA_ROOT),
was_grabbed);
}
gtk_container_add (GTK_CONTAINER (plug), op->priv->custom_widget);
gtk_widget_show (op->priv->custom_widget);
gtk_widget_show (plug);
- gdk_surface_focus (gtk_widget_get_surface (plug), GDK_CURRENT_TIME);
+ gdk_surface_focus (gtk_native_get_surface (gtk_widget_get_native (plug)), GDK_CURRENT_TIME);
/* This dialog is modal, so we grab the embed widget */
gtk_grab_add (plug);
invisible = gtk_window_new (GTK_WINDOW_POPUP);
parentHWnd = get_parent_hwnd (invisible);
}
- else
+ else
parentHWnd = get_parent_hwnd (GTK_WIDGET (parent));
printdlgex = (LPPRINTDLGEXW)GlobalAlloc (GPTR, sizeof (PRINTDLGEXW));
&iter_location.y);
gtk_menu_popup_at_rect (GTK_MENU (priv->popup_menu),
- gtk_widget_get_surface (GTK_WIDGET (text_view)),
+ gtk_native_get_surface (gtk_widget_get_native (GTK_WIDGET (text_view))),
&iter_location,
GDK_GRAVITY_SOUTH_EAST,
GDK_GRAVITY_NORTH_WEST,
toplevel = gtk_widget_get_toplevel (widget);
- if (gtk_widget_get_surface (toplevel) != surface)
+ if (gtk_native_get_surface (GTK_NATIVE (toplevel)) != surface)
return;
gtk_widget_translate_coordinates (toplevel, widget, round (x), round (y), &dx, &dy);
int anchor_rect_padding;
gtk_widget_realize (GTK_WIDGET (tooltip->current_window));
- surface = _gtk_widget_get_surface (GTK_WIDGET (tooltip->current_window));
+ surface = gtk_native_get_surface (GTK_NATIVE (tooltip->current_window));
tooltip->tooltip_widget = new_tooltip_widget;
* If the anchor rectangle isn't to tall, make sure the tooltip isn't too
* far away from the pointer position.
*/
- effective_toplevel = _gtk_widget_get_surface (toplevel);
+ effective_toplevel = gtk_native_get_surface (GTK_NATIVE (toplevel));
gdk_surface_get_device_position (effective_toplevel, device, &px, &py, NULL);
pointer_x = round (px);
pointer_y = round (py);
#include "gtkwidgetpath.h"
#include "gtkwidgetprivate.h"
#include "gtkwindowgroup.h"
+#include "gtknative.h"
#include "a11y/gtktreeviewaccessibleprivate.h"
GdkEvent *fevent;
GdkSurface *surface;
- surface = gtk_widget_get_surface (widget);
+ surface = gtk_native_get_surface (gtk_widget_get_native (widget));
fevent = gdk_event_new (GDK_FOCUS_CHANGE);
#include "gtkintl.h"
#include "gtkmediacontrols.h"
#include "gtkmediafile.h"
+#include "gtknative.h"
#include "gtkpicture.h"
#include "gtkrevealer.h"
GTK_WIDGET_CLASS (gtk_video_parent_class)->realize (widget);
if (self->media_stream)
- gtk_media_stream_realize (self->media_stream, gtk_widget_get_surface (GTK_WIDGET (self)));
+ {
+ GdkSurface *surface;
+
+ surface = gtk_native_get_surface (gtk_widget_get_native (widget));
+ gtk_media_stream_realize (self->media_stream, surface);
+ }
if (self->file)
gtk_media_file_set_file (GTK_MEDIA_FILE (self->media_stream), self->file);
GtkVideo *self = GTK_VIDEO (widget);
if (self->media_stream)
- gtk_media_stream_unrealize (self->media_stream, gtk_widget_get_surface (GTK_WIDGET (self)));
+ {
+ GdkSurface *surface;
+
+ surface = gtk_native_get_surface (gtk_widget_get_native (widget));
+ gtk_media_stream_unrealize (self->media_stream, surface);
+ }
GTK_WIDGET_CLASS (gtk_video_parent_class)->unrealize (widget);
}
gtk_video_notify_cb,
self);
if (gtk_widget_get_realized (GTK_WIDGET (self)))
- gtk_media_stream_unrealize (self->media_stream, gtk_widget_get_surface (GTK_WIDGET (self)));
+ {
+ GdkSurface *surface;
+
+ surface = gtk_native_get_surface (gtk_widget_get_native (GTK_WIDGET (self)));
+ gtk_media_stream_unrealize (self->media_stream, surface);
+ }
g_object_unref (self->media_stream);
self->media_stream = NULL;
}
self->media_stream = g_object_ref (stream);
gtk_media_stream_set_loop (stream, self->loop);
if (gtk_widget_get_realized (GTK_WIDGET (self)))
- gtk_media_stream_realize (stream, gtk_widget_get_surface (GTK_WIDGET (self)));
+ {
+ GdkSurface *surface;
+
+ surface = gtk_native_get_surface (gtk_widget_get_native (GTK_WIDGET (self)));
+ gtk_media_stream_realize (stream, surface);
+ }
g_signal_connect (self->media_stream,
"notify",
G_CALLBACK (gtk_video_notify_cb),
gint
gtk_widget_get_scale_factor (GtkWidget *widget)
{
+ GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GtkRoot *root;
GdkDisplay *display;
GdkMonitor *monitor;
g_return_val_if_fail (GTK_IS_WIDGET (widget), 1);
if (_gtk_widget_get_realized (widget))
- return gdk_surface_get_scale_factor (_gtk_widget_get_surface (widget));
+ return gdk_surface_get_scale_factor (priv->surface);
root = _gtk_widget_get_root (widget);
if (root && GTK_WIDGET (root) != widget)
guint button,
gint n_press)
{
+ GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
GtkSettings *settings;
gchar *action = NULL;
gboolean retval = TRUE;
_gtk_window_toggle_maximized (window);
}
else if (g_str_equal (action, "lower"))
- gdk_surface_lower (_gtk_widget_get_surface (GTK_WIDGET (window)));
+ gdk_surface_lower (priv->surface);
else if (g_str_equal (action, "minimize"))
- gdk_surface_iconify (_gtk_widget_get_surface (GTK_WIDGET (window)));
+ gdk_surface_iconify (priv->surface);
else if (g_str_equal (action, "menu"))
gtk_window_do_popup (window, (GdkEventButton*) event);
else
gdouble y,
GtkWindow *window)
{
+ GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
GtkWidget *event_widget, *widget;
GdkEventSequence *sequence;
GtkWindowRegion region;
- GtkWindowPrivate *priv;
const GdkEvent *event;
guint button;
gboolean window_drag = FALSE;
widget = GTK_WIDGET (window);
- priv = gtk_window_get_instance_private (window);
sequence = gtk_gesture_single_get_current_sequence (GTK_GESTURE_SINGLE (gesture));
button = gtk_gesture_single_get_current_button (GTK_GESTURE_SINGLE (gesture));
event = gtk_gesture_get_last_event (GTK_GESTURE (gesture), sequence);
event_widget = gtk_get_event_widget ((GdkEvent *) event);
if (region == GTK_WINDOW_REGION_TITLE)
- gdk_surface_raise (_gtk_widget_get_surface (widget));
+ gdk_surface_raise (priv->surface);
switch (region)
{
gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_CLAIMED);
gdk_event_get_coords (event, &tx, &ty);
- gdk_surface_begin_resize_drag_for_device (_gtk_widget_get_surface (widget),
+ gdk_surface_begin_resize_drag_for_device (priv->surface,
(GdkSurfaceEdge) region,
gdk_event_get_device ((GdkEvent *) event),
GDK_BUTTON_PRIMARY,
gtk_gesture_drag_get_start_point (gesture, &start_x, &start_y);
- gdk_surface_begin_move_drag_for_device (_gtk_widget_get_surface (GTK_WIDGET (window)),
+ gdk_surface_begin_move_drag_for_device (priv->surface,
gtk_gesture_get_device (GTK_GESTURE (gesture)),
gtk_gesture_single_get_current_button (GTK_GESTURE_SINGLE (gesture)),
(int)start_x, (int)start_y,
priv->maximized)
return FALSE;
- supports_edge_constraints = gdk_surface_supports_edge_constraints (_gtk_widget_get_surface (GTK_WIDGET (window)));
+ supports_edge_constraints = gdk_surface_supports_edge_constraints (priv->surface);
constraints = constraints_for_edge (edge);
if (!supports_edge_constraints && priv->tiled)
gboolean update_titlebar)
{
GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
- GtkWidget *widget;
char *new_title;
g_return_if_fail (GTK_IS_WINDOW (window));
- widget = GTK_WIDGET (window);
-
new_title = g_strdup (title);
g_free (priv->title);
priv->title = new_title;
- if (_gtk_widget_get_realized (widget))
- gdk_surface_set_title (_gtk_widget_get_surface (widget), new_title != NULL ? new_title : "");
+ if (_gtk_widget_get_realized (GTK_WIDGET (window)))
+ gdk_surface_set_title (priv->surface, new_title != NULL ? new_title : "");
if (update_titlebar && GTK_IS_HEADER_BAR (priv->title_box))
gtk_header_bar_set_title (GTK_HEADER_BAR (priv->title_box), new_title != NULL ? new_title : "");
if (_gtk_widget_get_realized (widget))
{
- GdkSurface *surface;
guint32 timestamp = extract_time_from_startup_id (priv->startup_id);
- surface = _gtk_widget_get_surface (widget);
-
#ifdef GDK_WINDOWING_X11
- if (timestamp != GDK_CURRENT_TIME && GDK_IS_X11_SURFACE(surface))
- gdk_x11_surface_set_user_time (surface, timestamp);
+ if (timestamp != GDK_CURRENT_TIME && GDK_IS_X11_SURFACE (priv->surface))
+ gdk_x11_surface_set_user_time (priv->surface, timestamp);
#endif
/* Here we differentiate real and "fake" startup notification IDs,
gtk_window_present_with_time (window, timestamp);
else
{
- gdk_surface_set_startup_id (surface, priv->startup_id);
+ gdk_surface_set_startup_id (priv->surface, priv->startup_id);
/* If window is mapped, terminate the startup-notification too */
if (_gtk_widget_get_mapped (widget) && !disable_startup_notification)
/* adjust desired modality state */
if (_gtk_widget_get_realized (widget))
- gdk_surface_set_modal_hint (_gtk_widget_get_surface (widget), priv->modal);
+ gdk_surface_set_modal_hint (priv->surface, priv->modal);
if (gtk_widget_get_visible (widget))
{
gtk_window_transient_parent_realized (GtkWidget *parent,
GtkWidget *window)
{
+ GtkWindowPrivate *priv = gtk_window_get_instance_private (GTK_WINDOW (window));
+ GtkWindowPrivate *parent_priv = gtk_window_get_instance_private (GTK_WINDOW (parent));
if (_gtk_widget_get_realized (window))
- gdk_surface_set_transient_for (_gtk_widget_get_surface (window),
- _gtk_widget_get_surface (parent));
+ gdk_surface_set_transient_for (priv->surface, parent_priv->surface);
}
static void
gtk_window_transient_parent_unrealized (GtkWidget *parent,
GtkWidget *window)
{
+ GtkWindowPrivate *priv = gtk_window_get_instance_private (GTK_WINDOW (window));
if (_gtk_widget_get_realized (window))
- gdk_surface_set_transient_for (_gtk_widget_get_surface (window), NULL);
+ gdk_surface_set_transient_for (priv->surface, NULL);
}
static void
*
* gtk_dialog_new_with_buttons() and other convenience functions in GTK+
* will sometimes call gtk_window_set_type_hint() on your behalf.
- *
**/
void
-gtk_window_set_type_hint (GtkWindow *window,
- GdkSurfaceTypeHint hint)
+gtk_window_set_type_hint (GtkWindow *window,
+ GdkSurfaceTypeHint hint)
{
GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
- GdkSurface *surface;
g_return_if_fail (GTK_IS_WINDOW (window));
priv->type_hint = hint;
- surface = _gtk_widget_get_surface (GTK_WIDGET (window));
- if (surface)
- gdk_surface_set_type_hint (surface, hint);
+ if (priv->surface)
+ gdk_surface_set_type_hint (priv->surface, hint);
g_object_notify_by_pspec (G_OBJECT (window), window_props[PROP_TYPE_HINT]);
{
priv->accept_focus = setting;
if (_gtk_widget_get_realized (GTK_WIDGET (window)))
- gdk_surface_set_accept_focus (_gtk_widget_get_surface (GTK_WIDGET (window)),
- priv->accept_focus);
+ gdk_surface_set_accept_focus (priv->surface, priv->accept_focus);
g_object_notify_by_pspec (G_OBJECT (window), window_props[PROP_ACCEPT_FOCUS]);
}
}
{
priv->focus_on_map = setting;
if (_gtk_widget_get_realized (GTK_WIDGET (window)))
- gdk_surface_set_focus_on_map (_gtk_widget_get_surface (GTK_WIDGET (window)),
- priv->focus_on_map);
+ gdk_surface_set_focus_on_map (priv->surface, priv->focus_on_map);
g_object_notify_by_pspec (G_OBJECT (window), window_props[PROP_FOCUS_ON_MAP]);
}
}
gboolean setting)
{
GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
- GdkSurface *surface;
g_return_if_fail (GTK_IS_WINDOW (window));
priv->decorated = setting;
- surface = _gtk_widget_get_surface (GTK_WIDGET (window));
- if (surface)
+ if (priv->surface)
{
if (priv->decorated)
{
if (priv->client_decorated)
- gdk_surface_set_decorations (surface, 0);
+ gdk_surface_set_decorations (priv->surface, 0);
else
- gdk_surface_set_decorations (surface, GDK_DECOR_ALL);
+ gdk_surface_set_decorations (priv->surface, GDK_DECOR_ALL);
}
else
- gdk_surface_set_decorations (surface, 0);
+ gdk_surface_set_decorations (priv->surface, 0);
}
update_window_buttons (window);
gboolean setting)
{
GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
- GdkSurface *surface;
g_return_if_fail (GTK_IS_WINDOW (window));
priv->deletable = setting;
- surface = _gtk_widget_get_surface (GTK_WIDGET (window));
- if (surface)
+ if (priv->surface)
{
if (priv->deletable)
- gdk_surface_set_functions (surface,
- GDK_FUNC_ALL);
+ gdk_surface_set_functions (priv->surface, GDK_FUNC_ALL);
else
- gdk_surface_set_functions (surface,
- GDK_FUNC_ALL | GDK_FUNC_CLOSE);
+ gdk_surface_set_functions (priv->surface,
+ GDK_FUNC_ALL | GDK_FUNC_CLOSE);
}
update_window_buttons (window);
gtk_window_realize_icon (GtkWindow *window)
{
GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
- GtkWidget *widget;
GtkWindowIconInfo *info;
- GdkSurface *surface;
GList *icon_list = NULL;
- widget = GTK_WIDGET (window);
- surface = _gtk_widget_get_surface (widget);
-
- g_return_if_fail (surface != NULL);
+ g_return_if_fail (priv->surface != NULL);
/* no point setting an icon on override-redirect */
if (priv->type == GTK_WINDOW_POPUP)
info->realized = TRUE;
- gdk_surface_set_icon_list (surface, icon_list);
+ gdk_surface_set_icon_list (priv->surface, icon_list);
if (GTK_IS_HEADER_BAR (priv->title_box))
_gtk_header_bar_update_window_icon (GTK_HEADER_BAR (priv->title_box), window);
- if (info->using_themed_icon)
- {
- g_list_free_full (icon_list, g_object_unref);
- }
+ if (info->using_themed_icon)
+ g_list_free_full (icon_list, g_object_unref);
}
GdkTexture *
* gtk_window_get_size(). Using the window allocation directly will not
* work in all circumstances and can lead to growing or shrinking windows.
*/
-void
+void
gtk_window_set_default_size (GtkWindow *window,
gint width,
gint height)
gint *width,
gint *height)
{
+ GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
gint w, h;
-
+
g_return_if_fail (GTK_IS_WINDOW (window));
if (width == NULL && height == NULL)
if (_gtk_widget_get_mapped (GTK_WIDGET (window)))
{
- w = gdk_surface_get_width (_gtk_widget_get_surface (GTK_WIDGET (window)));
- h = gdk_surface_get_height (_gtk_widget_get_surface (GTK_WIDGET (window)));
+ w = gdk_surface_get_width (priv->surface);
+ h = gdk_surface_get_height (priv->surface);
}
else
{
GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
GtkWidget *child;
GtkWindowGeometryInfo *info;
- GdkSurface *surface;
GdkSurfaceState state;
if (!_gtk_widget_is_toplevel (GTK_WIDGET (widget)))
return;
}
- surface = priv->surface;
-
GTK_WIDGET_CLASS (gtk_window_parent_class)->unmap (widget);
- gdk_surface_hide (surface);
+ gdk_surface_hide (priv->surface);
while (priv->configure_request_count > 0)
{
priv->configure_request_count--;
- gdk_surface_thaw_toplevel_updates (_gtk_widget_get_surface (widget));
+ gdk_surface_thaw_toplevel_updates (priv->surface);
}
priv->configure_notify_received = FALSE;
info->position_constraints_changed = FALSE;
}
- state = gdk_surface_get_state (surface);
+ state = gdk_surface_get_state (priv->surface);
priv->iconify_initially = (state & GDK_SURFACE_STATE_ICONIFIED) != 0;
priv->maximize_initially = (state & GDK_SURFACE_STATE_MAXIMIZED) != 0;
priv->stick_initially = (state & GDK_SURFACE_STATE_STICKY) != 0;
int *width,
int *height)
{
+ GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
GtkWindowGeometryInfo *info;
- GdkSurface *surface;
*width = 0;
*height = 0;
- surface = _gtk_widget_get_surface (GTK_WIDGET (window));
- if (surface)
+ if (priv->surface)
{
- *width = gdk_surface_get_width (surface);
- *height = gdk_surface_get_height (surface);
+ *width = gdk_surface_get_width (priv->surface);
+ *height = gdk_surface_get_height (priv->surface);
return;
}
update_shadow_width (GtkWindow *window,
GtkBorder *border)
{
- GdkSurface *surface;
-
- surface = _gtk_widget_get_surface (GTK_WIDGET (window));
+ GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
- if (surface)
- gdk_surface_set_shadow_width (surface,
+ if (priv->surface)
+ gdk_surface_set_shadow_width (priv->surface,
border->left,
border->right,
border->top,
const GtkBorder *border,
const GtkAllocation *allocation)
{
+ GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
GtkWidget *widget = GTK_WIDGET (window);
cairo_region_t *opaque_region;
GtkStyleContext *context;
opaque_region = NULL;
}
- gdk_surface_set_opaque_region (_gtk_widget_get_surface (widget), opaque_region);
+ gdk_surface_set_opaque_region (priv->surface, opaque_region);
cairo_region_destroy (opaque_region);
}
if (priv->transient_parent &&
_gtk_widget_get_realized (GTK_WIDGET (priv->transient_parent)))
- gdk_surface_set_transient_for (surface,
- _gtk_widget_get_surface (GTK_WIDGET (priv->transient_parent)));
+ {
+ GtkWindowPrivate *parent_priv = gtk_window_get_instance_private (priv->transient_parent);
+ gdk_surface_set_transient_for (surface, parent_priv->surface);
+ }
gdk_surface_set_type_hint (surface, priv->type_hint);
if (!_gtk_widget_is_toplevel (widget) && _gtk_widget_get_realized (widget))
{
- gdk_surface_move_resize (_gtk_widget_get_surface (widget), 0, 0, width, height);
+ gdk_surface_move_resize (priv->surface, 0, 0, width, height);
}
*allocation_out = child_allocation;
{
priv->configure_request_count -= 1;
- gdk_surface_thaw_toplevel_updates (_gtk_widget_get_surface (widget));
+ gdk_surface_thaw_toplevel_updates (priv->surface);
}
/*
GdkSurfaceState new_surface_state;
GdkSurfaceState changed_mask;
- new_surface_state = gdk_surface_get_state (_gtk_widget_get_surface (widget));
+ new_surface_state = gdk_surface_get_state (priv->surface);
changed_mask = new_surface_state ^ priv->state;
priv->state = new_surface_state;
GdkDevice *dev = gdk_seat_get_pointer (s->data);
GdkModifierType mask;
- gdk_device_get_state (dev, _gtk_widget_get_surface (GTK_WIDGET (window)),
- NULL, &mask);
+ gdk_device_get_state (dev, priv->surface, NULL, &mask);
if (priv->mnemonic_modifier == (mask & gtk_accelerator_get_default_mod_mask ()))
{
retval = TRUE;
event = gdk_event_new (GDK_FOCUS_CHANGE);
gdk_event_set_display (event, gtk_widget_get_display (GTK_WIDGET (window)));
gdk_event_set_device (event, device);
- event->any.surface = _gtk_widget_get_surface (GTK_WIDGET (window));
+ event->any.surface = priv->surface;
if (event->any.surface)
g_object_ref (event->any.surface);
static GdkSurfaceState
gtk_window_get_state (GtkWindow *window)
{
- GdkSurfaceState state;
- GdkSurface *surface;
-
- surface = gtk_widget_get_surface (GTK_WIDGET (window));
+ GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
- state = 0;
+ if (priv->surface)
+ return gdk_surface_get_state (priv->surface);
- if (surface)
- state = gdk_surface_get_state (surface);
-
- return state;
+ return 0;
}
static void
gtk_window_do_popup (GtkWindow *window,
GdkEventButton *event)
{
- if (!gdk_surface_show_window_menu (_gtk_widget_get_surface (GTK_WIDGET (window)),
- (GdkEvent *) event))
+ GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
+
+ if (!gdk_surface_show_window_menu (priv->surface, (GdkEvent *) event))
gtk_window_do_popup_fallback (window, event);
}
*********************************/
/* This function doesn't constrain to geometry hints */
-static void
+static void
gtk_window_compute_configure_request_size (GtkWindow *window,
GdkGeometry *geometry,
guint flags,
case GTK_WIN_POS_CENTER_ON_PARENT:
{
GtkAllocation allocation;
- GdkSurface *surface;
GdkMonitor *monitor;
GdkRectangle area;
gint ox, oy;
+ GtkWindowPrivate *parent_priv = gtk_window_get_instance_private (priv->transient_parent);
g_assert (_gtk_widget_get_mapped (parent_widget)); /* established earlier */
- surface = _gtk_widget_get_surface (parent_widget);
- monitor = gdk_display_get_monitor_at_surface (priv->display, surface);
+ monitor = gdk_display_get_monitor_at_surface (priv->display, parent_priv->surface);
- gdk_surface_get_origin (surface, &ox, &oy);
+ gdk_surface_get_origin (parent_priv->surface, &ox, &oy);
gtk_widget_get_allocation (parent_widget, &allocation);
x = ox + (allocation.width - w) / 2;
widget = GTK_WIDGET (window);
- surface = _gtk_widget_get_surface (widget);
+ surface = priv->surface;
info = gtk_window_get_geometry_info (window, TRUE);
configure_request_size_changed = FALSE;
if (gtk_widget_get_visible (widget))
{
- surface = _gtk_widget_get_surface (widget);
+ surface = priv->surface;
g_assert (surface != NULL);
gtk_window_iconify (GtkWindow *window)
{
GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
- GdkSurface *toplevel;
g_return_if_fail (GTK_IS_WINDOW (window));
priv->iconify_initially = TRUE;
- toplevel = _gtk_widget_get_surface (GTK_WIDGET (window));
-
- if (toplevel != NULL)
- gdk_surface_iconify (toplevel);
+ if (priv->surface)
+ gdk_surface_iconify (priv->surface);
}
/**
gtk_window_deiconify (GtkWindow *window)
{
GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
- GdkSurface *toplevel;
g_return_if_fail (GTK_IS_WINDOW (window));
priv->iconify_initially = FALSE;
- toplevel = _gtk_widget_get_surface (GTK_WIDGET (window));
-
- if (toplevel != NULL)
- gdk_surface_deiconify (toplevel);
+ if (priv->surface)
+ gdk_surface_deiconify (priv->surface);
}
/**
gtk_window_stick (GtkWindow *window)
{
GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
- GdkSurface *toplevel;
g_return_if_fail (GTK_IS_WINDOW (window));
priv->stick_initially = TRUE;
- toplevel = _gtk_widget_get_surface (GTK_WIDGET (window));
-
- if (toplevel != NULL)
- gdk_surface_stick (toplevel);
+ if (priv->surface)
+ gdk_surface_stick (priv->surface);
}
/**
gtk_window_unstick (GtkWindow *window)
{
GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
- GdkSurface *toplevel;
g_return_if_fail (GTK_IS_WINDOW (window));
priv->stick_initially = FALSE;
- toplevel = _gtk_widget_get_surface (GTK_WIDGET (window));
-
- if (toplevel != NULL)
- gdk_surface_unstick (toplevel);
+ if (priv->surface)
+ gdk_surface_unstick (priv->surface);
}
/**
gtk_window_maximize (GtkWindow *window)
{
GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
- GdkSurface *toplevel;
g_return_if_fail (GTK_IS_WINDOW (window));
priv->maximize_initially = TRUE;
- toplevel = _gtk_widget_get_surface (GTK_WIDGET (window));
-
- if (toplevel != NULL)
- gdk_surface_maximize (toplevel);
+ if (priv->surface)
+ gdk_surface_maximize (priv->surface);
}
/**
gtk_window_unmaximize (GtkWindow *window)
{
GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
- GdkSurface *toplevel;
g_return_if_fail (GTK_IS_WINDOW (window));
priv->maximize_initially = FALSE;
- toplevel = _gtk_widget_get_surface (GTK_WIDGET (window));
-
- if (toplevel != NULL)
- gdk_surface_unmaximize (toplevel);
+ if (priv->surface)
+ gdk_surface_unmaximize (priv->surface);
}
/**
gtk_window_fullscreen (GtkWindow *window)
{
GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
- GdkSurface *toplevel;
g_return_if_fail (GTK_IS_WINDOW (window));
priv->fullscreen_initially = TRUE;
- toplevel = _gtk_widget_get_surface (GTK_WIDGET (window));
-
- if (toplevel != NULL)
- gdk_surface_fullscreen (toplevel);
+ if (priv->surface)
+ gdk_surface_fullscreen (priv->surface);
}
static void
GdkMonitor *monitor)
{
GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
- GtkWidget *widget;
- GdkSurface *toplevel;
g_return_if_fail (GTK_IS_WINDOW (window));
g_return_if_fail (GDK_IS_MONITOR (monitor));
g_return_if_fail (gdk_monitor_is_valid (monitor));
- widget = GTK_WIDGET (window);
-
gtk_window_set_display (window, gdk_monitor_get_display (monitor));
unset_fullscreen_monitor (window);
priv->fullscreen_initially = TRUE;
- toplevel = _gtk_widget_get_surface (widget);
-
- if (toplevel != NULL)
- gdk_surface_fullscreen_on_monitor (toplevel, monitor);
+ if (priv->surface)
+ gdk_surface_fullscreen_on_monitor (priv->surface, monitor);
}
/**
gtk_window_unfullscreen (GtkWindow *window)
{
GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
- GdkSurface *toplevel;
g_return_if_fail (GTK_IS_WINDOW (window));
unset_fullscreen_monitor (window);
priv->fullscreen_initially = FALSE;
- toplevel = _gtk_widget_get_surface (GTK_WIDGET (window));
-
- if (toplevel != NULL)
- gdk_surface_unfullscreen (toplevel);
+ if (priv->surface)
+ gdk_surface_unfullscreen (priv->surface);
}
/**
gboolean setting)
{
GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
- GdkSurface *toplevel;
g_return_if_fail (GTK_IS_WINDOW (window));
priv->above_initially = setting;
priv->below_initially &= !setting;
- toplevel = _gtk_widget_get_surface (GTK_WIDGET (window));
-
- if (toplevel != NULL)
- gdk_surface_set_keep_above (toplevel, setting);
+ if (priv->surface)
+ gdk_surface_set_keep_above (priv->surface, setting);
}
/**
gboolean setting)
{
GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
- GdkSurface *toplevel;
g_return_if_fail (GTK_IS_WINDOW (window));
priv->below_initially = setting;
priv->above_initially &= !setting;
- toplevel = _gtk_widget_get_surface (GTK_WIDGET (window));
-
- if (toplevel != NULL)
- gdk_surface_set_keep_below (toplevel, setting);
+ if (priv->surface)
+ gdk_surface_set_keep_below (priv->surface, setting);
}
/**
gint y,
guint32 timestamp)
{
- GtkWidget *widget;
- GdkSurface *toplevel;
+ GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
g_return_if_fail (GTK_IS_WINDOW (window));
- widget = GTK_WIDGET (window);
- g_return_if_fail (gtk_widget_get_visible (widget));
-
- toplevel = _gtk_widget_get_surface (widget);
+ g_return_if_fail (gtk_widget_get_visible (GTK_WIDGET (window)));
- gdk_surface_begin_resize_drag (toplevel, edge, button, x, y, timestamp);
+ gdk_surface_begin_resize_drag (priv->surface, edge, button, x, y, timestamp);
}
/**
gint y,
guint32 timestamp)
{
- GtkWidget *widget;
- GdkSurface *toplevel;
+ GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
g_return_if_fail (GTK_IS_WINDOW (window));
- widget = GTK_WIDGET (window);
- g_return_if_fail (gtk_widget_get_visible (widget));
+ g_return_if_fail (gtk_widget_get_visible (GTK_WIDGET (window)));
- toplevel = _gtk_widget_get_surface (widget);
-
- gdk_surface_begin_move_drag (toplevel, button, x, y, timestamp);
+ gdk_surface_begin_move_drag (priv->surface, button, x, y, timestamp);
}
/**
{
#ifdef GDK_WINDOWING_X11
GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
- GdkSurface *surface;
gboolean dark_theme_requested;
g_object_get (gtk_settings_get_for_display (priv->display),
"gtk-application-prefer-dark-theme", &dark_theme_requested,
NULL);
- surface = _gtk_widget_get_surface (GTK_WIDGET (window));
-
- if (GDK_IS_X11_SURFACE (surface))
- gdk_x11_surface_set_theme_variant (surface,
- dark_theme_requested ? "dark" : NULL);
+ if (GDK_IS_X11_SURFACE (priv->surface))
+ gdk_x11_surface_set_theme_variant (priv->surface,
+ dark_theme_requested ? "dark" : NULL);
#endif
}
static void
ensure_state_flag_backdrop (GtkWidget *widget)
{
- GdkSurface *surface;
+ GtkWindowPrivate *priv = gtk_window_get_instance_private (GTK_WINDOW (widget));
gboolean surface_focused = TRUE;
- surface = _gtk_widget_get_surface (widget);
-
- surface_focused = gdk_surface_get_state (surface) & GDK_SURFACE_STATE_FOCUSED;
+ surface_focused = gdk_surface_get_state (priv->surface) & GDK_SURFACE_STATE_FOCUSED;
if (!surface_focused)
gtk_widget_set_state_flags (widget, GTK_STATE_FLAG_BACKDROP, FALSE);
GtkWindowHandleExported callback,
gpointer user_data)
{
+ GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
#ifdef GDK_WINDOWING_X11
if (GDK_IS_X11_DISPLAY (gtk_widget_get_display (GTK_WIDGET (window))))
{
- GdkSurface *surface = gtk_widget_get_surface (GTK_WIDGET (window));
char *handle_str;
- guint32 xid = (guint32) gdk_x11_surface_get_xid (surface);
+ guint32 xid = (guint32) gdk_x11_surface_get_xid (priv->surface);
handle_str = g_strdup_printf ("x11:%x", xid);
callback (window, handle_str, user_data);
#ifdef GDK_WINDOWING_WAYLAND
if (GDK_IS_WAYLAND_DISPLAY (gtk_widget_get_display (GTK_WIDGET (window))))
{
- GdkSurface *surface = gtk_widget_get_surface (GTK_WIDGET (window));
WaylandSurfaceHandleExportedData *data;
data = g_new0 (WaylandSurfaceHandleExportedData, 1);
data->callback = callback;
data->user_data = user_data;
- if (!gdk_wayland_surface_export_handle (surface,
+ if (!gdk_wayland_surface_export_handle (priv->surface,
wayland_surface_handle_exported,
data,
g_free))
void
gtk_window_unexport_handle (GtkWindow *window)
{
+ GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
+
#ifdef GDK_WINDOWING_WAYLAND
if (GDK_IS_WAYLAND_DISPLAY (gtk_widget_get_display (GTK_WIDGET (window))))
{
- GdkSurface *surface = gtk_widget_get_surface (GTK_WIDGET (window));
-
- gdk_wayland_surface_unexport_handle (surface);
+ gdk_wayland_surface_unexport_handle (priv->surface);
}
#endif
}
GdkCursor *cursor = NULL;
GdkSurface *surface;
- surface = gtk_widget_get_surface (target);
+ surface = gtk_native_get_surface (gtk_widget_get_native (target));
if (grab_widget && !gtk_widget_is_ancestor (target, grab_widget))
{
/* Outside the grab widget, cursor stays to whatever the grab
* widget says.
*/
- if (gtk_widget_get_surface (grab_widget) == gtk_widget_get_surface (target))
+ if (gtk_native_get_surface (gtk_widget_get_native (grab_widget)) == surface)
cursor = gtk_widget_get_cursor (grab_widget);
else
cursor = NULL;
break;
/* Don't inherit cursors across surfaces */
- if (surface != gtk_widget_get_surface (target))
+ if (surface != gtk_native_get_surface (gtk_widget_get_native (target)))
break;
cursor = gtk_widget_get_cursor (target);
#include "gtkintl.h"
#include "gtkwidget.h"
#include "gtkwindow.h"
+#include "gtknative.h"
/* duration before we start fading in us */
#define GDK_FPS_OVERLAY_LINGER_DURATION (1000 * 1000)
GdkFrameClock *clock,
gpointer unused)
{
- gdk_surface_queue_expose (gtk_widget_get_surface (widget));
+ gdk_surface_queue_expose (gtk_native_get_surface (gtk_widget_get_native (widget)));
return G_SOURCE_REMOVE;
}
g_hash_table_iter_init (&iter, self->infos);
while (g_hash_table_iter_next (&iter, &widget, NULL))
- gdk_surface_queue_expose (gtk_widget_get_surface (widget));
+ gdk_surface_queue_expose (gtk_native_get_surface (gtk_widget_get_native (widget)));
}
static void
{
double x, y;
- gdk_surface_get_device_position (gtk_widget_get_surface (widget),
+ gdk_surface_get_device_position (gtk_native_get_surface (GTK_NATIVE (widget)),
device, &x, &y, NULL);
widget = gtk_widget_pick (widget, x, y, GTK_PICK_INSENSITIVE|GTK_PICK_NON_TARGETABLE);
{
GtkWidget *widget;
- gdk_surface_raise (gtk_widget_get_surface (GTK_WIDGET (iw)));
+ gdk_surface_raise (gtk_native_get_surface (GTK_NATIVE (iw)));
clear_flash (iw);
cairo_region_destroy (region);
}
else
- gdk_surface_lower (gtk_widget_get_surface (window));
+ gdk_surface_lower (gtk_native_get_surface (GTK_NATIVE (window)));
}
static void
gtk_widget_input_shape_combine_region (window, NULL);
}
else
- gdk_surface_raise (gtk_widget_get_surface (window));
+ gdk_surface_raise (gtk_native_get_surface (GTK_NATIVE (window)));
}
static gboolean handle_event (GtkInspectorWindow *iw, GdkEvent *event);
#include "gtkintl.h"
#include "gtkwidget.h"
+#include "gtknative.h"
#include "gsk/gskrendernodeprivate.h"
gtk_update_free (draw);
}
- gdk_surface_queue_expose (gtk_widget_get_surface (widget));
+ gdk_surface_queue_expose (gtk_native_get_surface (gtk_widget_get_native (widget)));
if (draw)
{
g_queue_push_tail (updates->updates, draw);
g_hash_table_iter_init (&iter, self->toplevels);
while (g_hash_table_iter_next (&iter, &widget, NULL))
- gdk_surface_queue_expose (gtk_widget_get_surface (widget));
+ gdk_surface_queue_expose (gtk_native_get_surface (gtk_widget_get_native (widget)));
}
static void
GdkFullscreenMode mode = (GdkFullscreenMode) GPOINTER_TO_INT (user_data);
GdkSurface *window;
- window = gtk_widget_get_surface (gtk_widget_get_parent (widget));
+ window = gtk_native_get_surface (gtk_widget_get_native (widget));
gdk_surface_set_fullscreen_mode (window, mode);
gdk_surface_fullscreen (window);
}
{
GdkSurface *window;
- window = gtk_widget_get_surface (gtk_widget_get_parent (widget));
+ window = gtk_native_get_surface (gtk_widget_get_native (widget));
gdk_surface_unfullscreen (window);
}
button = gtk_button_new ();
gtk_container_add (GTK_CONTAINER (box2), button);
- gdk_surface = gtk_widget_get_surface (window);
+ gdk_surface = gtk_native_get_surface (GTK_NATIVE (window));
pixbufwid = new_pixbuf ("test.xpm", gdk_surface);
gtk_widget_realize (window);
- gdk_surface = gtk_widget_get_surface (window);
+ gdk_surface = gtk_native_get_surface (GTK_NATIVE (window));
pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **) openfile);
texture = gdk_texture_new_for_pixbuf (pixbuf);
gtk_container_add (GTK_CONTAINER (hbox), label);
g_object_set_data (G_OBJECT (label), "title", (gpointer)gtk_window_get_title (GTK_WINDOW (window)));
- g_signal_connect (gtk_widget_get_surface (window), "notify::state",
+ g_signal_connect (gtk_native_get_surface (GTK_NATIVE (window)), "notify::state",
G_CALLBACK (surface_state_callback),
label);
gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_CLAIMED);
- surface = gtk_widget_get_surface (widget);
+ surface = gtk_native_get_surface (gtk_widget_get_native (widget));
event = gtk_get_current_event ();
gdk_event_get_button (event, &button);
timestamp = gdk_event_get_time (event);
gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_CLAIMED);
- surface = gtk_widget_get_surface (widget);
+ surface = gtk_native_get_surface (gtk_widget_get_native (widget));
event = gtk_get_current_event ();
gdk_event_get_button (event, &button);
timestamp = gdk_event_get_time (event);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog), label, GTK_RESPONSE_HELP);
gtk_widget_realize (dialog);
- g_signal_connect (gtk_widget_get_surface (dialog), "size-changed",
+ g_signal_connect (gtk_native_get_surface (GTK_NATIVE (dialog)), "size-changed",
G_CALLBACK (size_changed_cb), label);
gtk_dialog_run (GTK_DIALOG (dialog));
GdkDisplay *display;
GdkDevice *device;
GdkSeat *seat;
+ GdkSurface *surface;
GdkEvent *ev;
display = gtk_widget_get_display (widget);
seat = gdk_display_get_default_seat (display);
device = gdk_seat_get_pointer (seat);
+ surface = gtk_native_get_surface (gtk_widget_get_native (widget));
if (point == &mouse_state)
{
ev = gdk_event_new (GDK_BUTTON_PRESS);
- ev->any.surface = g_object_ref (gtk_widget_get_surface (widget));
+ ev->any.surface = g_object_ref (surface);
ev->button.time = GDK_CURRENT_TIME;
ev->button.x = point->x;
ev->button.y = point->y;
else
{
ev = gdk_event_new (GDK_TOUCH_BEGIN);
- ev->any.surface = g_object_ref (gtk_widget_get_surface (widget));
+ ev->any.surface = g_object_ref (surface);
ev->touch.time = GDK_CURRENT_TIME;
ev->touch.x = point->x;
ev->touch.y = point->y;
GdkDisplay *display;
GdkDevice *device;
GdkSeat *seat;
+ GdkSurface *surface;
GdkEvent *ev;
display = gtk_widget_get_display (widget);
seat = gdk_display_get_default_seat (display);
device = gdk_seat_get_pointer (seat);
+ surface = gtk_native_get_surface (gtk_widget_get_native (widget));
point->x = x;
point->y = y;
if (point == &mouse_state)
{
ev = gdk_event_new (GDK_MOTION_NOTIFY);
- ev->any.surface = g_object_ref (gtk_widget_get_surface (widget));
+ ev->any.surface = g_object_ref (surface);
ev->button.time = GDK_CURRENT_TIME;
ev->motion.x = x;
ev->motion.y = y;
return;
ev = gdk_event_new (GDK_TOUCH_UPDATE);
- ev->any.surface = g_object_ref (gtk_widget_get_surface (widget));
+ ev->any.surface = g_object_ref (surface);
ev->touch.time = GDK_CURRENT_TIME;
ev->touch.x = x;
ev->touch.y = y;
GdkDisplay *display;
GdkDevice *device;
GdkSeat *seat;
+ GdkSurface *surface;
GdkEvent *ev;
if (point->widget == NULL)
display = gtk_widget_get_display (point->widget);
seat = gdk_display_get_default_seat (display);
device = gdk_seat_get_pointer (seat);
+ surface = gtk_native_get_surface (gtk_widget_get_native (point->widget));
if (!point->widget)
return;
return;
ev = gdk_event_new (GDK_BUTTON_RELEASE);
- ev->any.surface = g_object_ref (gtk_widget_get_surface (point->widget));
+ ev->any.surface = g_object_ref (surface);
ev->button.time = GDK_CURRENT_TIME;
ev->button.x = point->x;
ev->button.y = point->y;
else
{
ev = gdk_event_new (GDK_TOUCH_END);
- ev->any.surface = g_object_ref (gtk_widget_get_surface (point->widget));
+ ev->any.surface = g_object_ref (surface);
ev->touch.time = GDK_CURRENT_TIME;
ev->touch.x = point->x;
ev->touch.y = point->y;
projects / gtk4.git / commitdiff